package manage_admin_controller

import (
	"fmt"
	manage_dao "manage-server/dao/manage"
	"manage-server/db"
	"manage-server/middleware"
	"manage-server/model/manage_model"
	"manage-server/util"
	"net/http"

	"github.com/gin-gonic/gin"
)

type AdminController struct{}

// @Summary 后台用户管理用户登录
// @Schemes
// @Description 后台用户管理用户登录
// @Tags 后台用户管理
// @Param Object body manage_dao.ManageUserLoginReqDao true "后台用户登录参数"     参数 ：@Param 参数名 位置（query 或者 path或者 body） 类型 是否必需 注释
// @Accept application/x-www-form-urlencoded
// @Produce application/json
// @Router /manage/admin/login [post]
func (AdminController) Login(ctx *gin.Context) {
	username := ctx.PostForm("username")
	password := ctx.PostForm("password")
	fmt.Println(username, password)
	// 验证表单
	if username == "" || password == "" {
		util.Success(ctx, util.R{
			P: util.P{
				Message: "用户名或密码不能为空",
			},
		})
		return
	}
	// 查找数据库
	mu, err := manage_dao.GetUserIsExists(username)
	if err != nil {
		util.Fail(ctx, util.R{
			P: util.P{
				Message: err.Error(),
			},
		})
		return
	}
	// 检测用户密码
	b := util.CompareHashAndPassword(mu.Password, password)
	if !b {
		util.Fail(ctx, util.R{
			P: util.P{
				Message: "用户或密码错误",
			},
		})
		return
	}
	// 生成 Token
	token, err := middleware.CreateToken(mu.ID, mu.Username)
	if err != nil {
		util.Success(ctx, util.R{
			P: util.P{
				Code:    http.StatusOK,
				Message: err.Error(),
			},
		})
		return
	}
	util.Success(ctx, util.R{
		P: util.P{
			Message: "登录成功",
			Params: gin.H{
				"data": gin.H{
					"token": token,
				},
			},
		},
	})
}

// @Summary 后台用户管理用户Token刷新
// @Schemes
// @Description 后台用户管理用户Token刷新
// @Tags 后台用户管理
// @Param Object body manage_dao.ManageUserLoginReqDao true "后台用户登录参数"     参数 ：@Param 参数名 位置（query 或者 path或者 body） 类型 是否必需 注释
// @Accept application/x-www-form-urlencoded
// @Produce application/json
// @Router /manage/admin/refresh_token [post]
func (AdminController) RefreshToken(ctx *gin.Context) {
	id, _ := ctx.Get("id")
	username, _ := ctx.Get("username")
	token, err := middleware.CreateToken(id.(uint), username.(string))
	if err != nil {
		util.Success(ctx, util.R{
			P: util.P{
				Code:    http.StatusOK,
				Message: err.Error(),
			},
		})
		return
	}
	util.Success(ctx, util.R{
		P: util.P{
			Message: "刷新Token成功",
			Params: gin.H{
				"data": gin.H{
					"token": token,
				},
			},
		},
	})
}

// @Summary 后台用户管理用户信息
// @Schemes
// @Description 后台用户管理用户信息
// @Tags 后台用户管理
// @Param Id query int true "Id"     参数 ：@Param 参数名 位置（query 或者 path或者 body） 类型 是否必需 注释
// @Accept json
// @Produce json
// @Router /manage/admin/info [get]
func (AdminController) Info(ctx *gin.Context) {
	id, _ := ctx.Get("id")
	username, _ := ctx.Get("username")
	// mu := manage_dao.GetUserInfo(id.(string), username.(string))
	db := db.GetManageDB()
	manageUser := manage_model.ManageUser{}
	db.Model(&manageUser).Where("id = ?", id).Or("username = ?", username).First(&manageUser)
	util.Success(ctx, util.R{
		P: util.P{
			Message: "获取成功",
			Params: gin.H{
				"data": gin.H{
					"id":       manageUser.ID,
					"username": manageUser.Username,
					"nickname": manageUser.Nickname,
					"fullname": manageUser.Fullname,
					"is_super": manageUser.IsSuper,
					"role_id":  manageUser.RoleId,
					"avatar":   manageUser.Avatar,
				},
			},
		},
	})
}

// @Summary 后台用户管理用户列表查询
// @Schemes
// @Description 后台用户管理用户列表查询
// @Tags 后台用户管理
// @Param Id query int true "Id"     参数 ：@Param 参数名 位置（query 或者 path或者 body） 类型 是否必需 注释
// @Accept json
// @Produce json
// @Router /manage/admin/page [get]
func (AdminController) Page(ctx *gin.Context) {
	p := &util.Paginator{}
	err := ctx.ShouldBindQuery(p)
	if err != nil {
		util.Success(ctx, util.R{
			P: util.P{
				Message: err.Error(),
			},
		})
		return
	}
	// 解析 offset
	err = util.PaginatorHandler(p)
	if err != nil {
		util.Success(ctx, util.R{
			P: util.P{
				Message: err.Error(),
			},
		})
		return
	}
	list, err := manage_dao.GetUserAll(p)
	if err != nil {
		util.Success(ctx, util.R{
			P: util.P{
				Message: err.Error(),
			},
		})
		return
	}
	util.Success(ctx, util.R{
		P: util.P{
			Message: "获取成功",
			Params: gin.H{
				"data": gin.H{
					"list":      list,
					"paginator": p,
				},
			},
		},
	})
}

// @Summary 后台用户管理用户编辑
// @Schemes
// @Description 后台用户管理用户编辑
// @Tags 后台用户管理
// @Param Id query int true "Id"     参数 ：@Param 参数名 位置（query 或者 path或者 body） 类型 是否必需 注释
// @Accept json
// @Produce json
// @Router /manage/admin/edit [post]
func (AdminController) Edit(ctx *gin.Context) {
	ctx.JSON(200, gin.H{})
}

// @Summary 后台用户管理用户新增
// @Schemes
// @Description 后台用户管理用户新增
// @Tags 后台用户管理
// @Param Id query int true "Id"     参数 ：@Param 参数名 位置（query 或者 path或者 body） 类型 是否必需 注释
// @Accept json
// @Produce json
// @Router /manage/admin/create [get]
func (AdminController) Add(ctx *gin.Context) {
	username, _ := ctx.Get("username")
	// 查询是否为管理员
	mu, err := manage_dao.GetUserIsExists(username.(string))
	if err != nil {
		util.Success(ctx, util.R{
			P: util.P{
				Message: err.Error(),
			},
		})
		return
	}
	if mu.IsSuper != 1 {
		util.Success(ctx, util.R{
			P: util.P{
				Message: "没有权限",
			},
		})
		return
	}
	db := db.ManageDB
	// 获取请求参数
	user := &manage_dao.ManageUserAddReqDao{}
	err = ctx.ShouldBindQuery(user)
	if err != nil {
		util.Success(ctx, util.R{
			P: util.P{
				Message: err.Error(),
			},
		})
		return
	}
	if user.Username == "" || user.Password == "" {
		util.Success(ctx, util.R{
			P: util.P{
				Message: "用户名或密码不能为空",
			},
		})
		return
	}
	newUser := manage_model.ManageUser{}
	// 查询新增用户是否存在
	db.Model(&newUser).Where("username = ?", user.Username).First(&newUser)
	if newUser.Username == user.Username {
		util.Success(ctx, util.R{
			P: util.P{
				Message: "用户名已存在",
			},
		})
		return
	}
	bcryptPassword, err := util.GenerateFromPassword(user.Password)
	if err != nil {
		util.Success(ctx, util.R{
			P: util.P{
				Message: err.Error(),
			},
		})
		return
	}
	db.Model(&newUser).Create(&manage_model.ManageUser{
		Username: user.Username,
		Password: bcryptPassword,
		Status:   user.Status,
		IsSuper:  user.IsSuper,
		RoleId:   user.RoleId,
	})
	util.Success(ctx, util.R{
		P: util.P{
			Message: "新增成功",
		},
	})
	fmt.Println(user)
	fmt.Println(mu.ID, mu.Username)
}

// @Summary 后台用户管理用户删除
// @Schemes
// @Description 后台用户管理用户删除
// @Tags 后台用户管理
// @Param Id query int true "Id"     参数 ：@Param 参数名 位置（query 或者 path或者 body） 类型 是否必需 注释
// @Accept json
// @Produce json
// @Router /manage/admin/delete [post]
func (AdminController) Delete(ctx *gin.Context) {
	ctx.JSON(200, gin.H{})
}
